#include <stdio.h>
#include <stdlib.h>
#include "slave.h"
/*
t_aresta parseToAresta(int id){
	t_aresta aresta;
	if(id>0){
		aresta = arestas_ids[id];	
	}else{
		aresta.id = 0;
		aresta.origem = 0;
		aresta.destino=0;
	}
	//printf("%d = {%d , %d} %d\n",id , aresta.origem,aresta.destino,aresta.id);
	return aresta;
}

void parseToSolucao(t_aresta solucao[][3],int sol[][2],int tam){
	int i;

	for(i=1;i<=tam;i++){
		solucao[i][1] = parseToAresta(sol[i-1][0]);
		solucao[i][2] = parseToAresta(sol[i-1][1]);
	}
}

void parseToInt(int sol[][2],t_aresta solucao[][3],int ndemandas){
	int i;

	for(i=1;i<=ndemandas;i++){
		sol[i-1][0] = solucao[i][1].id;
		sol[i-1][1] = solucao[i][2].id;
	}
}*/

void init_slave(int id,int nnos, int narestas, int ndemandas,int semente,	int num_vezes[MAX_NOS + 1][MAX_NOS + 1]){
	MPI_Status status;
	unsigned int	membersize, maxsize,i,j;
	int position;
	int dest, tag,custo,custo_pr,custo_b,custo_f,melhor_custo;
	char *buffer;

	int tamanho;
	
	int tipo = 0;
	
	t_aresta solucao[MAX_DEMANDA+1][3];
	t_aresta melhor_solucao[MAX_DEMANDA+1][3];
	t_aresta melhor_solucao_pr[MAX_DEMANDA+1][3];
	t_aresta solucao_pr[MAX_DEMANDA+1][3];
	int num_vezes_pool[MAX_NOS + 1][MAX_NOS + 1];

	custo = 0;
	Inicia_Solucao(nnos, ndemandas, num_vezes, solucao);

// PEDE PADRAO PARA O MASTER
/*	tipo = ENVIA_PADRAO; 
	MPI_Send(&tipo, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);
	MPI_Recv(&tamanho, sizeof(tamanho), MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
	if(tamanho>0){
		int array[tamanho];
		MPI_Recv(array, tamanho, MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
		printf("Recebeu Padrao com tamanho %d\n",tamanho);
	}*/

//CONSTRUCAO
   custo = GulosoRandomizadoDemanda(nnos, ndemandas, demanda, incidencia, num_vezes, &semente, solucao);

//BUSCA LOCAL
   BuscaLocalDemanda(solucao, &custo, ndemandas, demanda, incidencia, num_vezes, nnos, &semente);

	melhor_custo = custo;
	CopiaSolucao(solucao, melhor_solucao, ndemandas);
	printf("melhor = %d\n",melhor_custo);
//ENVIA SOLUCAO DA BUSCA LOCAL PARA O MASTER
	tipo = RECEBE_SOLUCAO_BL; 
	MPI_Send(&tipo, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);
	printf("slave connected!\n");
	tamanho = ndemandas;
	MPI_Send(&tamanho, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);
//	printf("(%d %d) = %d\n",solucao[1][1].origem,solucao[1][1].destino,ids[solucao[1][1].origem][solucao[1][1].destino]);
	int array[tamanho][2];
	parseToInt(array,solucao,tamanho);
	printf("slave enviando BL\n");
	//for(i=0;i<tamanho;i++)
	//	printf("(%d,%d), ",array[i][0],array[i][1]);
	//printf("\n");
	MPI_Send(array, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD);

	MPI_Send(&custo, sizeof(custo), MPI_INT, 0, 1, MPI_COMM_WORLD);
	
//PEDE SOLUCAO PARA MASTER
/*
	tipo = ENVIA_SOLUCAO; 
	MPI_Send(&tipo, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);

	printf("slave esperando solucao para PR\n");
	printf("melhor = %d\n",melhor_custo);
	MPI_Recv(&tamanho, sizeof(tamanho), MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
	printf("melhor2 = %d\n",melhor_custo);
*/
/*	if(tamanho>0){
		printf("matriz len = %d\n",tamanho);
		int array[tamanho][2];
		MPI_Recv(array, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
		MPI_Recv(&custo_pr, sizeof(custo_pr), MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
		printf("Recebeu Solucao com tamanho %d de custo %d\n",tamanho,custo);
		parseToSolucao(solucao_pr,array,tamanho);

		//INICIA PR
		CalculaNumeroVezes(solucao_pr, num_vezes_pool, ndemandas, nnos);
      custo_b = PR(solucao_pr, &custo_pr, num_vezes_pool, solucao, ndemandas, nnos, melhor_solucao_pr, incidencia); 

		if(melhor_custo > custo_b){ 
			melhor_custo = custo_b;
		   CopiaSolucao(melhor_solucao_pr, melhor_solucao, ndemandas);
		}

		CalculaNumeroVezes(solucao_pr, num_vezes_pool, ndemandas, nnos);
      custo_f = PR(solucao, &custo_pr, num_vezes_pool, solucao_pr, ndemandas, nnos, melhor_solucao_pr, incidencia); 

		if(melhor_custo > custo_f){ 
			melhor_custo = custo_f;
		   CopiaSolucao(melhor_solucao_pr, melhor_solucao, ndemandas);
		}

	}


*/
//ENVIA A MELHOR SOLUCAO

	printf("preparando para eviar melhor\n");
	tipo = RECEBE_SOLUCAO; 
	MPI_Send(&tipo, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);

	tamanho = ndemandas;
	
	MPI_Send(&tamanho, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);

	int array2[tamanho][2];
//	MostraSolucoes(solucao, melhor_solucao,ndemandas);

	parseToInt(array2,solucao);
	printf("enviando melhor...\n");
	MPI_Send(array2, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD);

	printf("enviando melhorc %d %dx...\n",melhor_custo,custo);
	MPI_Send(&melhor_custo, sizeof(melhor_custo), MPI_INT, 0, 1, MPI_COMM_WORLD);


/*


	for(j=0;j<=3;j++){
		tipo = j;
		MPI_Send(&tipo, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);
		if(tipo==RECEBE_SOLUCAO){//MANDA SOLUCAO PRO MASTER
			tamanho = ndemandas;
			custo = 5;
			MPI_Send(&tamanho, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);

			int array[tamanho][2];
			for(i=0;i<tamanho;i++){
				array[i][0] = get_rand_ij(&ssemente, 1, narestas);
				array[i][1] = get_rand_ij(&semente, 0, narestas);
			}

			MPI_Send(array, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD);

			MPI_Send(&custo, sizeof(custo), MPI_INT, 0, 1, MPI_COMM_WORLD);
		
		}else if(tipo==RECEBE_SOLUCAO_BL){//MANDA SOLUCAO DA BUSCA LOCAL PRO MASTER
			tamanho = ndemandas;
			custo = 5;
			printf("slave tamanho enviando BL\n");
			MPI_Send(&tamanho, sizeof(int), MPI_INT, 0, 1, MPI_COMM_WORLD);

			int array[tamanho][2];
			for(i=0;i<tamanho;i++){
				array[i][0] = get_rand_ij(&semente, 1, narestas);
				array[i][1] = get_rand_ij(&semente, 0, narestas);
			}
			printf("slave enviando BL\n");
			MPI_Send(array, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD);

			MPI_Send(&custo, sizeof(custo), MPI_INT, 0, 1, MPI_COMM_WORLD);
		
		}else if(tipo == ENVIA_PADRAO){ //RECEBE PADRAO DO MASTER
			MPI_Recv(&tamanho, sizeof(tamanho), MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
			if(tamanho>0){
				int array[tamanho];
				MPI_Recv(array, tamanho, MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
				printf("Recebeu Padrao com tamanho %d\n",tamanho);

			//	for(i=0;i<tamanho;i++)
			//		printf("%d, ",array[i]);
			//	printf("\n");
			}

		}else if(tipo == ENVIA_SOLUCAO){
			printf("slave esperando solucao\n");
			MPI_Recv(&tamanho, sizeof(tamanho), MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
			if(tamanho>0){
				printf("matriz len = %d\n",tamanho);
				int array[tamanho][2];
				MPI_Recv(array, tamanho*2, MPI_INT, 0, 1, MPI_COMM_WORLD,&status);
				printf("Recebeu Solucao com tamanho %d\n",tamanho);

			//	for(i=0;i<tamanho;i++)
			//		printf("(%d %d), ",array[i][0],array[i][1]);
			//	printf("\n");
			}
		}

	}
*/
	printf("slave %d saiu!\n",id);
}


